/*
 * Copyright (c) 2000, 2004, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package javax.print.attribute.standard;

import javax.print.attribute.EnumSyntax;
import javax.print.attribute.Attribute;

/**
 * Class JobStateReason is a printing attribute class, an enumeration, that
 * provides additional information about the job's current state, i.e.,
 * information that augments the value of the job's {@link JobState JobState}
 * attribute. Class JobStateReason defines standard job state reason values. A
 * Print Service implementation only needs to report those job state
 * reasons which are appropriate for the particular implementation; it does not
 * have to report every defined job state reason.
 * <P>
 * Instances of JobStateReason do not appear in a Print Job's attribute set
 * directly. Rather, a {@link JobStateReasons JobStateReasons} attribute appears
 * in the Print Job's attribute set. The {@link JobStateReasons JobStateReasons}
 * attribute contains zero, one, or more than one JobStateReason objects which
 * pertain to the Print Job's status. The printer adds a JobStateReason object
 * to the Print Job's {@link JobStateReasons JobStateReasons} attribute when the
 * corresponding condition becomes true of the Print Job, and the printer
 * removes the JobStateReason object again when the corresponding condition
 * becomes false, regardless of whether the Print Job's overall {@link JobState
 * JobState} also changed.
 * <P>
 * <B>IPP Compatibility:</B> The category name returned by
 * <CODE>getName()</CODE> is the IPP attribute name.  The enumeration's
 * integer value is the IPP enum value.  The <code>toString()</code> method
 * returns the IPP string representation of the attribute value.
 * <P>
 *
 * @author Alan Kaminsky
 */
public class JobStateReason extends EnumSyntax implements Attribute {

  private static final long serialVersionUID = -8765894420449009168L;

  /**
   * The printer has created the Print Job, but the printer has not finished
   * accessing or accepting all the print data yet.
   */
  public static final JobStateReason
      JOB_INCOMING = new JobStateReason(0);

  /**
   * The printer has created the Print Job, but the printer is expecting
   * additional print data before it can move the job into the PROCESSING
   * state. If a printer starts processing before it has received all data,
   * the printer removes the JOB_DATA_INSUFFICIENT reason, but the
   * JOB_INCOMING reason remains. If a printer starts processing after it
   * has received all data, the printer removes the JOB_DATA_INSUFFICIENT
   * and JOB_INCOMING reasons at the same time.
   */
  public static final JobStateReason
      JOB_DATA_INSUFFICIENT = new JobStateReason(1);

  /**
   * The Printer could not access one or more documents passed by reference
   * (i.e., the print data representation object is a URL). This reason is
   * intended to cover any file access problem,including file does not exist
   * and access denied because of an access control problem. Whether the
   * printer aborts the job and moves the job to the ABORTED job state or
   * prints all documents that are accessible and moves the job to the
   * COMPLETED job state and adds the COMPLETED_WITH_ERRORS reason to the
   * job's {@link JobStateReasons JobStateReasons} attribute depends on
   * implementation and/or site policy. This value should be supported if
   * the printer supports doc flavors with URL print data representation
   * objects.
   */
  public static final JobStateReason
      DOCUMENT_ACCESS_ERROR = new JobStateReason(2);

  /**
   * The job was not completely submitted for some unforeseen reason.
   * Possibilities include (1) the printer has crashed before the job was
   * fully submitted by the client, (2) the printer or the document transfer
   * method has crashed in some non-recoverable way before the document data
   * was entirely transferred to the printer, (3) the client crashed before
   * the job was fully submitted.
   */
  public static final JobStateReason
      SUBMISSION_INTERRUPTED = new JobStateReason(3);

  /**
   * The printer is transmitting the job to the output device.
   */
  public static final JobStateReason
      JOB_OUTGOING = new JobStateReason(4);

  /**
   * The value of the job's {@link JobHoldUntil JobHoldUntil} attribute was
   * specified with a date-time that is still in the future. The job must
   * not be a candidate for processing until this reason is removed and
   * there are
   * no other reasons to hold the job. This value should be supported if the
   * {@link JobHoldUntil JobHoldUntil} job template attribute is supported.
   */
  public static final JobStateReason
      JOB_HOLD_UNTIL_SPECIFIED = new JobStateReason(5);

  /**
   * At least one of the resources needed by the job, such as media, fonts,
   * resource objects, etc., is not ready on any of the physical printers
   * for which the job is a candidate. This condition may be detected
   * when the job is accepted, or subsequently while the job is pending
   * or processing, depending on implementation.
   * The job may remain in its current state or
   * be moved to the PENDING_HELD state, depending on implementation and/or
   * job scheduling policy.
   */
  public static final JobStateReason
      RESOURCES_ARE_NOT_READY = new JobStateReason(6);

  /**
   * The value of the printer's {@link PrinterStateReasons
   * PrinterStateReasons} attribute contains a {@link PrinterStateReason
   * PrinterStateReason} value of STOPPED_PARTLY.
   */
  public static final JobStateReason
      PRINTER_STOPPED_PARTLY = new JobStateReason(7);

  /**
   * The value of the printer's {@link PrinterState PrinterState} attribute
   * ia STOPPED.
   */
  public static final JobStateReason
      PRINTER_STOPPED = new JobStateReason(8);

  /**
   * The job is in the PROCESSING state, but more specifically, the printer
   * ia interpreting the document data.
   */
  public static final JobStateReason
      JOB_INTERPRETING = new JobStateReason(9);

  /**
   * The job is in the PROCESSING state, but more specifically, the printer
   * has queued the document data.
   */
  public static final JobStateReason JOB_QUEUED = new JobStateReason(10);

  /**
   * The job is in the PROCESSING state, but more specifically, the printer
   * is interpreting document data and producing another electronic
   * representation.
   */
  public static final JobStateReason
      JOB_TRANSFORMING = new JobStateReason(11);

  /**
   * The job is in the PENDING_HELD, PENDING, or PROCESSING state, but more
   * specifically, the printer has completed enough processing of the document
   * to be able to start marking and the job is waiting for the marker.
   * Systems that require human intervention to release jobs put the job into
   * the PENDING_HELD job state. Systems that automatically select a job to
   * use the marker put the job into the PENDING job state or keep the job
   * in the PROCESSING job state while waiting for the marker, depending on
   * implementation. All implementations put the job into (or back into) the
   * PROCESSING state when marking does begin.
   */
  public static final JobStateReason
      JOB_QUEUED_FOR_MARKER = new JobStateReason(12);

  /**
   * The output device is marking media. This value is useful for printers
   * which spend a great deal of time processing (1) when no marking is
   * happening and then want to show that marking is now happening or (2) when
   * the job is in the process of being canceled or aborted while the job
   * remains in the PROCESSING state, but the marking has not yet stopped so
   * that impression or sheet counts are still increasing for the job.
   */
  public static final JobStateReason
      JOB_PRINTING = new JobStateReason(13);

  /**
   * The job was canceled by the owner of the job, i.e., by a user whose
   * authenticated identity is the same as the value of the originating user
   * that created the Print Job, or by some other authorized end-user, such as
   * a member of the job owner's security group. This value should be
   * supported.
   */
  public static final JobStateReason
      JOB_CANCELED_BY_USER = new JobStateReason(14);

  /**
   * The job was canceled by the operator, i.e., by a user who has been
   * authenticated as having operator privileges (whether local or remote). If
   * the security policy is to allow anyone to cancel anyone's job, then this
   * value may be used when the job is canceled by someone other than the
   * owner of the job. For such a security policy, in effect, everyone is an
   * operator as far as canceling jobs is concerned. This value should be
   * supported if the implementation permits canceling by someone other than
   * the owner of the job.
   */
  public static final JobStateReason
      JOB_CANCELED_BY_OPERATOR = new JobStateReason(15);

  /**
   * The job was canceled by an unidentified local user, i.e., a user at a
   * console at the device. This value should be supported if the
   * implementation supports canceling jobs at the console.
   */
  public static final JobStateReason
      JOB_CANCELED_AT_DEVICE = new JobStateReason(16);

  /**
   * The job was aborted by the system. Either the job (1) is in the process
   * of being aborted, (2) has been aborted by the system and placed in the
   * ABORTED state, or (3) has been aborted by the system and placed in the
   * PENDING_HELD state, so that a user or operator can manually try the job
   * again. This value should be supported.
   */
  public static final JobStateReason
      ABORTED_BY_SYSTEM = new JobStateReason(17);

  /**
   * The job was aborted by the system because the printer determined while
   * attempting to decompress the document's data that the compression is
   * actually not among those supported by the printer. This value must be
   * supported, since {@link Compression Compression} is a required doc
   * description attribute.
   */
  public static final JobStateReason
      UNSUPPORTED_COMPRESSION = new JobStateReason(18);

  /**
   * The job was aborted by the system because the printer encountered an
   * error in the document data while decompressing it. If the printer posts
   * this reason, the document data has already passed any tests that would
   * have led to the UNSUPPORTED_COMPRESSION job state reason.
   */
  public static final JobStateReason
      COMPRESSION_ERROR = new JobStateReason(19);

  /**
   * The job was aborted by the system because the document data's document
   * format (doc flavor) is not among those supported by the printer. If the
   * client specifies a doc flavor with a MIME type of
   * <CODE>"application/octet-stream"</CODE>, the printer may abort the job if
   * the printer cannot determine the document data's actual format through
   * auto-sensing (even if the printer supports the document format if
   * specified explicitly). This value must be supported, since a doc flavor
   * is required to be specified for each doc.
   */
  public static final JobStateReason
      UNSUPPORTED_DOCUMENT_FORMAT = new JobStateReason(20);

  /**
   * The job was aborted by the system because the printer encountered an
   * error in the document data while processing it. If the printer posts this
   * reason, the document data has already passed any tests that would have
   * led to the UNSUPPORTED_DOCUMENT_FORMAT job state reason.
   */
  public static final JobStateReason
      DOCUMENT_FORMAT_ERROR = new JobStateReason(21);

  /**
   * The requester has canceled the job or the printer has aborted the job,
   * but the printer is still performing some actions on the job until a
   * specified stop point occurs or job termination/cleanup is completed.
   * <P>
   * If the implementation requires some measurable time to cancel the job in
   * the PROCESSING or PROCESSING_STOPPED job states, the printer must use
   * this reason to indicate that the printer is still performing some actions
   * on the job while the job remains in the PROCESSING or PROCESSING_STOPPED
   * state. After all the job's job description attributes have stopped
   * incrementing, the printer moves the job from the PROCESSING state to the
   * CANCELED or ABORTED job states.
   */
  public static final JobStateReason
      PROCESSING_TO_STOP_POINT = new JobStateReason(22);

  /**
   * The printer is off-line and accepting no jobs. All PENDING jobs are put
   * into the PENDING_HELD state. This situation could be true if the
   * service's or document transform's input is impaired or broken.
   */
  public static final JobStateReason
      SERVICE_OFF_LINE = new JobStateReason(23);

  /**
   * The job completed successfully. This value should be supported.
   */
  public static final JobStateReason
      JOB_COMPLETED_SUCCESSFULLY = new JobStateReason(24);

  /**
   * The job completed with warnings. This value should be supported if the
   * implementation detects warnings.
   */
  public static final JobStateReason
      JOB_COMPLETED_WITH_WARNINGS = new JobStateReason(25);

  /**
   * The job completed with errors (and possibly warnings too). This value
   * should be supported if the implementation detects errors.
   */
  public static final JobStateReason
      JOB_COMPLETED_WITH_ERRORS = new JobStateReason(26);

  /**
   * This job is retained and is currently able to be restarted. If
   * JOB_RESTARTABLE is contained in the job's {@link JobStateReasons
   * JobStateReasons} attribute, then the printer must accept a request to
   * restart that job. This value should be supported if restarting jobs is
   * supported. <I>[The capability for restarting jobs is not in the Java
   * Print Service API at present.]</I>
   */
  public static final JobStateReason
      JOB_RESTARTABLE = new JobStateReason(27);

  /**
   * The job has been forwarded to a device or print system that is unable to
   * send back status. The printer sets the job's {@link JobState JobState}
   * attribute to COMPLETED and adds the QUEUED_IN_DEVICE reason to the job's
   * {@link JobStateReasons JobStateReasons} attribute to indicate that the
   * printer has no additional information about the job and never will have
   * any better information.
   */
  public static final JobStateReason
      QUEUED_IN_DEVICE = new JobStateReason(28);

  /**
   * Construct a new job state reason enumeration value with the given
   * integer  value.
   *
   * @param value Integer value.
   */
  protected JobStateReason(int value) {
    super(value);
  }

  private static final String[] myStringTable = {
      "job-incoming",
      "job-data-insufficient",
      "document-access-error",
      "submission-interrupted",
      "job-outgoing",
      "job-hold-until-specified",
      "resources-are-not-ready",
      "printer-stopped-partly",
      "printer-stopped",
      "job-interpreting",
      "job-queued",
      "job-transforming",
      "job-queued-for-marker",
      "job-printing",
      "job-canceled-by-user",
      "job-canceled-by-operator",
      "job-canceled-at-device",
      "aborted-by-system",
      "unsupported-compression",
      "compression-error",
      "unsupported-document-format",
      "document-format-error",
      "processing-to-stop-point",
      "service-off-line",
      "job-completed-successfully",
      "job-completed-with-warnings",
      "job-completed-with-errors",
      "job-restartable",
      "queued-in-device"};

  private static final JobStateReason[] myEnumValueTable = {
      JOB_INCOMING,
      JOB_DATA_INSUFFICIENT,
      DOCUMENT_ACCESS_ERROR,
      SUBMISSION_INTERRUPTED,
      JOB_OUTGOING,
      JOB_HOLD_UNTIL_SPECIFIED,
      RESOURCES_ARE_NOT_READY,
      PRINTER_STOPPED_PARTLY,
      PRINTER_STOPPED,
      JOB_INTERPRETING,
      JOB_QUEUED,
      JOB_TRANSFORMING,
      JOB_QUEUED_FOR_MARKER,
      JOB_PRINTING,
      JOB_CANCELED_BY_USER,
      JOB_CANCELED_BY_OPERATOR,
      JOB_CANCELED_AT_DEVICE,
      ABORTED_BY_SYSTEM,
      UNSUPPORTED_COMPRESSION,
      COMPRESSION_ERROR,
      UNSUPPORTED_DOCUMENT_FORMAT,
      DOCUMENT_FORMAT_ERROR,
      PROCESSING_TO_STOP_POINT,
      SERVICE_OFF_LINE,
      JOB_COMPLETED_SUCCESSFULLY,
      JOB_COMPLETED_WITH_WARNINGS,
      JOB_COMPLETED_WITH_ERRORS,
      JOB_RESTARTABLE,
      QUEUED_IN_DEVICE};

  /**
   * Returns the string table for class JobStateReason.
   */
  protected String[] getStringTable() {
    return (String[]) myStringTable.clone();
  }

  /**
   * Returns the enumeration value table for class JobStateReason.
   */
  protected EnumSyntax[] getEnumValueTable() {
    return (EnumSyntax[]) myEnumValueTable.clone();
  }


  /**
   * Get the printing attribute class which is to be used as the "category"
   * for this printing attribute value.
   * <P>
   * For class JobStateReason and any vendor-defined subclasses, the
   * category  is class JobStateReason itself.
   *
   * @return Printing attribute class (category), an instance of class {@link java.lang.Class
   * java.lang.Class}.
   */
  public final Class<? extends Attribute> getCategory() {
    return JobStateReason.class;
  }

  /**
   * Get the name of the category of which this attribute value is an
   * instance.
   * <P>
   * For class JobStateReason and any vendor-defined subclasses, the
   * category name is <CODE>"job-state-reason"</CODE>.
   *
   * @return Attribute category name.
   */
  public final String getName() {
    return "job-state-reason";
  }

}
